home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 002 / emacssrc.arc / FILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-02-02  |  19.1 KB  |  606 lines
  1. /*    FILE.C:   for MicroEMACS
  2.  
  3.  
  4.  
  5.     The routines in this file handle the reading, writing
  6.  
  7.     and lookup of disk files.  All of details about the
  8.  
  9.     reading and writing of the disk are in "fileio.c".
  10.  
  11.  
  12.  
  13. */
  14.  
  15.  
  16.  
  17. #include        <stdio.h>
  18.  
  19. #include    "estruct.h"
  20.  
  21. #include        "edef.h"
  22.  
  23.  
  24.  
  25. #if    MEGAMAX
  26.  
  27. overlay "file"
  28.  
  29. #endif
  30.  
  31.  
  32.  
  33. /*
  34.  
  35.  * Read a file into the current
  36.  
  37.  * buffer. This is really easy; all you do it
  38.  
  39.  * find the name of the file, and call the standard
  40.  
  41.  * "read a file into the current buffer" code.
  42.  
  43.  * Bound to "C-X C-R".
  44.  
  45.  */
  46.  
  47. fileread(f, n)
  48.  
  49. {
  50.  
  51.         register int    s;
  52.  
  53.         char fname[NFILEN];
  54.  
  55.  
  56.  
  57.     if (restflag)        /* don't allow this command if restricted */
  58.  
  59.         return(resterr());
  60.  
  61.         if ((s=mlreply("Read file: ", fname, NFILEN)) != TRUE)
  62.  
  63.                 return(s);
  64.  
  65.         return(readin(fname, TRUE));
  66.  
  67. }
  68.  
  69.  
  70.  
  71. /*
  72.  
  73.  * Insert a file into the current
  74.  
  75.  * buffer. This is really easy; all you do it
  76.  
  77.  * find the name of the file, and call the standard
  78.  
  79.  * "insert a file into the current buffer" code.
  80.  
  81.  * Bound to "C-X C-I".
  82.  
  83.  */
  84.  
  85. insfile(f, n)
  86.  
  87. {
  88.  
  89.         register int    s;
  90.  
  91.         char fname[NFILEN];
  92.  
  93.  
  94.  
  95.     if (restflag)        /* don't allow this command if restricted */
  96.  
  97.         return(resterr());
  98.  
  99.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  100.  
  101.         return(rdonly());    /* we are in read only mode    */
  102.  
  103.         if ((s=mlreply("Insert file: ", fname, NFILEN)) != TRUE)
  104.  
  105.                 return(s);
  106.  
  107.         return(ifile(fname));
  108.  
  109. }
  110.  
  111.  
  112.  
  113. /*
  114.  
  115.  * Select a file for editing.
  116.  
  117.  * Look around to see if you can find the
  118.  
  119.  * fine in another buffer; if you can find it
  120.  
  121.  * just switch to the buffer. If you cannot find
  122.  
  123.  * the file, create a new buffer, read in the
  124.  
  125.  * text, and switch to the new buffer.
  126.  
  127.  * Bound to C-X C-F.
  128.  
  129.  */
  130.  
  131. filefind(f, n)
  132.  
  133. {
  134.  
  135.         char fname[NFILEN];    /* file user wishes to find */
  136.  
  137.         register int s;        /* status return */
  138.  
  139.  
  140.  
  141.     if (restflag)        /* don't allow this command if restricted */
  142.  
  143.         return(resterr());
  144.  
  145.         if ((s=mlreply("Find file: ", fname, NFILEN)) != TRUE)
  146.  
  147.                 return(s);
  148.  
  149.     return(getfile(fname, TRUE));
  150.  
  151. }
  152.  
  153.  
  154.  
  155. viewfile(f, n)    /* visit a file in VIEW mode */
  156.  
  157. {
  158.  
  159.         char fname[NFILEN];    /* file user wishes to find */
  160.  
  161.         register int s;        /* status return */
  162.  
  163.     register WINDOW *wp;    /* scan for windows that need updating */
  164.  
  165.  
  166.  
  167.     if (restflag)        /* don't allow this command if restricted */
  168.  
  169.         return(resterr());
  170.  
  171.         if ((s=mlreply("View file: ", fname, NFILEN)) != TRUE)
  172.  
  173.                 return (s);
  174.  
  175.     s = getfile(fname, FALSE);
  176.  
  177.     if (s) {    /* if we succeed, put it in view mode */
  178.  
  179.         curwp->w_bufp->b_mode |= MDVIEW;
  180.  
  181.  
  182.  
  183.         /* scan through and update mode lines of all windows */
  184.  
  185.         wp = wheadp;
  186.  
  187.         while (wp != NULL) {
  188.  
  189.             wp->w_flag |= WFMODE;
  190.  
  191.             wp = wp->w_wndp;
  192.  
  193.         }
  194.  
  195.     }
  196.  
  197.     return(s);
  198.  
  199. }
  200.  
  201.  
  202.  
  203. #if    CRYPT
  204.  
  205. resetkey()    /* reset the encryption key if needed */
  206.  
  207.  
  208.  
  209. {
  210.  
  211.     register int s;    /* return status */
  212.  
  213.  
  214.  
  215.     /* turn off the encryption flag */
  216.  
  217.     cryptflag = FALSE;
  218.  
  219.  
  220.  
  221.     /* if we are in crypt mode */
  222.  
  223.     if (curbp->b_mode & MDCRYPT) {
  224.  
  225.         if (curbp->b_key[0] == 0) {
  226.  
  227.             s = setkey(FALSE, 0);
  228.  
  229.             if (s != TRUE)
  230.  
  231.                 return(s);
  232.  
  233.         }
  234.  
  235.  
  236.  
  237.         /* let others know... */
  238.  
  239.         cryptflag = TRUE;
  240.  
  241.  
  242.  
  243.         /* and set up the key to be used! */
  244.  
  245.         /* de-encrypt it */
  246.  
  247.         crypt((char *)NULL, 0);
  248.  
  249.         crypt(curbp->b_key, strlen(curbp->b_key));
  250.  
  251.  
  252.  
  253.         /* re-encrypt it...seeding it to start */
  254.  
  255.         crypt((char *)NULL, 0);
  256.  
  257.         crypt(curbp->b_key, strlen(curbp->b_key));
  258.  
  259.     }
  260.  
  261.  
  262.  
  263.     return(TRUE);
  264.  
  265. }
  266.  
  267. #endif
  268.  
  269.  
  270.  
  271. getfile(fname, lockfl)
  272.  
  273.  
  274.  
  275. char fname[];        /* file name to find */
  276.  
  277. int lockfl;        /* check the file for locks? */
  278.  
  279.  
  280.  
  281. {
  282.  
  283.         register BUFFER *bp;
  284.  
  285.         register LINE   *lp;
  286.  
  287.         register int    i;
  288.  
  289.         register int    s;
  290.  
  291.         char bname[NBUFN];    /* buffer name to put file */
  292.  
  293.  
  294.  
  295.         for (bp=bheadp; bp!=NULL; bp=bp->b_bufp) {
  296.  
  297.                 if ((bp->b_flag&BFINVS)==0 && strcmp(bp->b_fname, fname)==0) {
  298.  
  299.             swbuffer(bp);
  300.  
  301.                         lp = curwp->w_dotp;
  302.  
  303.                         i = curwp->w_ntrows/2;
  304.  
  305.                         while (i-- && lback(lp)!=curbp->b_linep)
  306.  
  307.                                 lp = lback(lp);
  308.  
  309.                         curwp->w_linep = lp;
  310.  
  311.                         curwp->w_flag |= WFMODE|WFHARD;
  312.  
  313.                         mlwrite("[Old buffer]");
  314.  
  315.                         return (TRUE);
  316.  
  317.                 }
  318.  
  319.         }
  320.  
  321.         makename(bname, fname);                 /* New buffer name.     */
  322.  
  323.         while ((bp=bfind(bname, FALSE, 0)) != NULL) {
  324.  
  325.                 s = mlreply("Buffer name: ", bname, NBUFN);
  326.  
  327.                 if (s == ABORT)                 /* ^G to just quit      */
  328.  
  329.                         return (s);
  330.  
  331.                 if (s == FALSE) {               /* CR to clobber it     */
  332.  
  333.                         makename(bname, fname);
  334.  
  335.                         break;
  336.  
  337.                 }
  338.  
  339.         }
  340.  
  341.         if (bp==NULL && (bp=bfind(bname, TRUE, 0))==NULL) {
  342.  
  343.                 mlwrite("Cannot create buffer");
  344.  
  345.                 return (FALSE);
  346.  
  347.         }
  348.  
  349.         if (--curbp->b_nwnd == 0) {             /* Undisplay.           */
  350.  
  351.                 curbp->b_dotp = curwp->w_dotp;
  352.  
  353.                 curbp->b_doto = curwp->w_doto;
  354.  
  355.                 curbp->b_markp = curwp->w_markp;
  356.  
  357.                 curbp->b_marko = curwp->w_marko;
  358.  
  359.         }
  360.  
  361.         curbp = bp;                             /* Switch to it.        */
  362.  
  363.         curwp->w_bufp = bp;
  364.  
  365.         curbp->b_nwnd++;
  366.  
  367.         return(readin(fname, lockfl));          /* Read it in.          */
  368.  
  369. }
  370.  
  371.  
  372.  
  373. /*
  374.  
  375.  * Read file "fname" into the current
  376.  
  377.  * buffer, blowing away any text found there. Called
  378.  
  379.  * by both the read and find commands. Return the final
  380.  
  381.  * status of the read. Also called by the mainline,
  382.  
  383.  * to read in a file specified on the command line as
  384.  
  385.  * an argument. If the filename ends in a ".c", CMODE is
  386.  
  387.  * set for the current buffer.
  388.  
  389.  */
  390.  
  391. readin(fname, lockfl)
  392.  
  393.  
  394.  
  395. char    fname[];    /* name of file to read */
  396.  
  397. int    lockfl;        /* check for file locks? */
  398.  
  399.  
  400.  
  401. {
  402.  
  403.         register LINE   *lp1;
  404.  
  405.         register LINE   *lp2;
  406.  
  407.         register int    i;
  408.  
  409.         register WINDOW *wp;
  410.  
  411.         register BUFFER *bp;
  412.  
  413.         register int    s;
  414.  
  415.         register int    nbytes;
  416.  
  417.         register int    nline;
  418.  
  419.     register char    *sptr;        /* pointer into filename string */
  420.  
  421.     int        lflag;        /* any lines longer than allowed? */
  422.  
  423.         char            line[NLINE];
  424.  
  425.  
  426.  
  427. #if    FILOCK
  428.  
  429.     if (lockfl && lockchk(fname) == ABORT)
  430.  
  431.         return(ABORT);
  432.  
  433. #endif
  434.  
  435. #if    CRYPT
  436.  
  437.     s = resetkey();
  438.  
  439.     if (s != TRUE)
  440.  
  441.         return(s);
  442.  
  443. #endif
  444.  
  445.         bp = curbp;                             /* Cheap.               */
  446.  
  447.         if ((s=bclear(bp)) != TRUE)             /* Might be old.        */
  448.  
  449.                 return (s);
  450.  
  451.         bp->b_flag &= ~(BFINVS|BFCHG);
  452.  
  453. #if    ACMODE
  454.  
  455.     if (strlen(fname) > 1) {        /* check if a 'C' file    */
  456.  
  457.         sptr = fname + strlen(fname) - 2;
  458.  
  459.         if (*sptr == '.' &&
  460.  
  461.            (*(sptr + 1) == 'c' || *(sptr + 1) == 'h'))
  462.  
  463.             bp->b_mode |= MDCMOD;
  464.  
  465.     }
  466.  
  467. #endif
  468.  
  469.         strcpy(bp->b_fname, fname);
  470.  
  471.  
  472.  
  473.     /* turn off ALL keyboard translation in case we get a dos error */
  474.  
  475.     TTkclose();
  476.  
  477.  
  478.  
  479.         if ((s=ffropen(fname)) == FIOERR)       /* Hard file open.      */
  480.  
  481.                 goto out;
  482.  
  483.         if (s == FIOFNF) {                      /* File not found.      */
  484.  
  485.                 mlwrite("[New file]");
  486.  
  487.                 goto out;
  488.  
  489.         }
  490.  
  491.         mlwrite("[Reading file]");
  492.  
  493.         nline = 0;
  494.  
  495.     lflag = FALSE;
  496.  
  497.         while ((s=ffgetline(line, NLINE)) == FIOSUC || s == FIOLNG
  498.  
  499.             || s == FIOFUN) {
  500.  
  501.         if (s == FIOLNG) {
  502.  
  503.             lflag = TRUE;
  504.  
  505.             --nline;
  506.  
  507.         }
  508.  
  509.                 nbytes = strlen(line);
  510.  
  511.                 if ((lp1=lalloc(nbytes)) == NULL) {
  512.  
  513.                         s = FIOERR;             /* Keep message on the  */
  514.  
  515.                         break;                  /* display.             */
  516.  
  517.                 }
  518.  
  519.                 lp2 = lback(curbp->b_linep);
  520.  
  521.                 lp2->l_fp = lp1;
  522.  
  523.                 lp1->l_fp = curbp->b_linep;
  524.  
  525.                 lp1->l_bp = lp2;
  526.  
  527.                 curbp->b_linep->l_bp = lp1;
  528.  
  529.                 for (i=0; i<nbytes; ++i)
  530.  
  531.                         lputc(lp1, i, line[i]);
  532.  
  533.                 ++nline;
  534.  
  535.                 if (s == FIOFUN)
  536.  
  537.                     break;
  538.  
  539.         }
  540.  
  541.         ffclose();                              /* Ignore errors.       */
  542.  
  543.     strcpy(line, "[");
  544.  
  545.     if (lflag)
  546.  
  547.         strcat(line, "Long lines wrapped, ");
  548.  
  549.     if (s == FIOFUN)
  550.  
  551.         strcat(line, "Funny line at EOF, ");
  552.  
  553.         if (s == FIOEOF || s == FIOFUN) {        /* Don't zap message!   */
  554.  
  555.         sprintf(&line[strlen(line)], "Read %d line", nline);
  556.  
  557.                 if (nline > 1)
  558.  
  559.             strcat(line, "s");
  560.  
  561.         strcat(line, "]");
  562.  
  563.         }
  564.  
  565.     if (s != FIOERR)
  566.  
  567.         mlwrite(line);
  568.  
  569.  
  570.  
  571. out:
  572.  
  573.     TTkopen();    /* open the keyboard again */
  574.  
  575.         for (wp=wheadp; wp!=NULL; wp=wp->w_wndp) {
  576.  
  577.                 if (wp->w_bufp == curbp) {
  578.  
  579.                         wp->w_linep = lforw(curbp->b_linep);
  580.  
  581.                         wp->w_dotp  = lforw(curbp->b_linep);
  582.  
  583.                         wp->w_doto  = 0;
  584.  
  585.                         wp->w_markp = NULL;
  586.  
  587.                         wp->w_marko = 0;
  588.  
  589.                         wp->w_flag |= WFMODE|WFHARD;
  590.  
  591.                 }
  592.  
  593.         }
  594.  
  595.         if (s == FIOERR || s == FIOFNF)        /* False if error.      */
  596.  
  597.                 return(FALSE);
  598.  
  599.         return (TRUE);
  600.  
  601. }
  602.  
  603.  
  604.  
  605. /*
  606.  
  607.  * Take a file name, and from it
  608.  
  609.  * fabricate a buffer name. This routine knows
  610.  
  611.  * about the syntax of file names on the target system.
  612.  
  613.  * I suppose that this information could be put in
  614.  
  615.  * a better place than a line of code.
  616.  
  617.  */
  618.  
  619. makename(bname, fname)
  620.  
  621. char    bname[];
  622.  
  623. char    fname[];
  624.  
  625. {
  626.  
  627.         register char   *cp1;
  628.  
  629.         register char   *cp2;
  630.  
  631.  
  632.  
  633.         cp1 = &fname[0];
  634.  
  635.         while (*cp1 != 0)
  636.  
  637.                 ++cp1;
  638.  
  639.  
  640.  
  641. #if     AMIGA
  642.  
  643.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='/')
  644.  
  645.                 --cp1;
  646.  
  647. #endif
  648.  
  649. #if     VMS
  650.  
  651.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!=']')
  652.  
  653.                 --cp1;
  654.  
  655. #endif
  656.  
  657. #if     CPM
  658.  
  659.         while (cp1!=&fname[0] && cp1[-1]!=':')
  660.  
  661.                 --cp1;
  662.  
  663. #endif
  664.  
  665. #if     MSDOS
  666.  
  667.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\'&&cp1[-1]!='/')
  668.  
  669.                 --cp1;
  670.  
  671. #endif
  672.  
  673. #if     ST520
  674.  
  675.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\')
  676.  
  677.                 --cp1;
  678.  
  679. #endif
  680.  
  681. #if     FINDER
  682.  
  683.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\'&&cp1[-1]!='/')
  684.  
  685.                 --cp1;
  686.  
  687. #endif
  688.  
  689. #if     V7 | USG | BSD
  690.  
  691.         while (cp1!=&fname[0] && cp1[-1]!='/')
  692.  
  693.                 --cp1;
  694.  
  695. #endif
  696.  
  697.         cp2 = &bname[0];
  698.  
  699.         while (cp2!=&bname[NBUFN-1] && *cp1!=0 && *cp1!=';')
  700.  
  701.                 *cp2++ = *cp1++;
  702.  
  703.         *cp2 = 0;
  704.  
  705. }
  706.  
  707.  
  708.  
  709. /*
  710.  
  711.  * Ask for a file name, and write the
  712.  
  713.  * contents of the current buffer to that file.
  714.  
  715.  * Update the remembered file name and clear the
  716.  
  717.  * buffer changed flag. This handling of file names
  718.  
  719.  * is different from the earlier versions, and
  720.  
  721.  * is more compatable with Gosling EMACS than
  722.  
  723.  * with ITS EMACS. Bound to "C-X C-W".
  724.  
  725.  */
  726.  
  727. filewrite(f, n)
  728.  
  729. {
  730.  
  731.         register WINDOW *wp;
  732.  
  733.         register int    s;
  734.  
  735.         char            fname[NFILEN];
  736.  
  737.  
  738.  
  739.     if (restflag)        /* don't allow this command if restricted */
  740.  
  741.         return(resterr());
  742.  
  743.         if ((s=mlreply("Write file: ", fname, NFILEN)) != TRUE)
  744.  
  745.                 return (s);
  746.  
  747.         if ((s=writeout(fname)) == TRUE) {
  748.  
  749.                 strcpy(curbp->b_fname, fname);
  750.  
  751.                 curbp->b_flag &= ~BFCHG;
  752.  
  753.                 wp = wheadp;                    /* Update mode lines.   */
  754.  
  755.                 while (wp != NULL) {
  756.  
  757.                         if (wp->w_bufp == curbp)
  758.  
  759.                                 wp->w_flag |= WFMODE;
  760.  
  761.                         wp = wp->w_wndp;
  762.  
  763.                 }
  764.  
  765.         }
  766.  
  767.         return (s);
  768.  
  769. }
  770.  
  771.  
  772.  
  773. /*
  774.  
  775.  * Save the contents of the current
  776.  
  777.  * buffer in its associatd file. No nothing
  778.  
  779.  * if nothing has changed (this may be a bug, not a
  780.  
  781.  * feature). Error if there is no remembered file
  782.  
  783.  * name for the buffer. Bound to "C-X C-S". May
  784.  
  785.  * get called by "C-Z".
  786.  
  787.  */
  788.  
  789. filesave(f, n)
  790.  
  791. {
  792.  
  793.         register WINDOW *wp;
  794.  
  795.         register int    s;
  796.  
  797.  
  798.  
  799.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  800.  
  801.         return(rdonly());    /* we are in read only mode    */
  802.  
  803.         if ((curbp->b_flag&BFCHG) == 0)         /* Return, no changes.  */
  804.  
  805.                 return (TRUE);
  806.  
  807.         if (curbp->b_fname[0] == 0) {           /* Must have a name.    */
  808.  
  809.                 mlwrite("No file name");
  810.  
  811.                 return (FALSE);
  812.  
  813.         }
  814.  
  815.         if ((s=writeout(curbp->b_fname)) == TRUE) {
  816.  
  817.                 curbp->b_flag &= ~BFCHG;
  818.  
  819.                 wp = wheadp;                    /* Update mode lines.   */
  820.  
  821.                 while (wp != NULL) {
  822.  
  823.                         if (wp->w_bufp == curbp)
  824.  
  825.                                 wp->w_flag |= WFMODE;
  826.  
  827.                         wp = wp->w_wndp;
  828.  
  829.                 }
  830.  
  831.         }
  832.  
  833.         return (s);
  834.  
  835. }
  836.  
  837.  
  838.  
  839. /*
  840.  
  841.  * This function performs the details of file
  842.  
  843.  * writing. Uses the file management routines in the
  844.  
  845.  * "fileio.c" package. The number of lines written is
  846.  
  847.  * displayed. Sadly, it looks inside a LINE; provide
  848.  
  849.  * a macro for this. Most of the grief is error
  850.  
  851.  * checking of some sort.
  852.  
  853.  */
  854.  
  855. writeout(fn)
  856.  
  857. char    *fn;
  858.  
  859. {
  860.  
  861.         register int    s;
  862.  
  863.         register LINE   *lp;
  864.  
  865.         register int    nline;
  866.  
  867.  
  868.  
  869. #if    CRYPT
  870.  
  871.     s = resetkey();
  872.  
  873.     if (s != TRUE)
  874.  
  875.         return(s);
  876.  
  877. #endif
  878.  
  879.     /* turn off ALL keyboard translation in case we get a dos error */
  880.  
  881.     TTkclose();
  882.  
  883.  
  884.  
  885.         if ((s=ffwopen(fn)) != FIOSUC) {        /* Open writes message. */
  886.  
  887.         TTkopen();
  888.  
  889.                 return (FALSE);
  890.  
  891.         }
  892.  
  893.     mlwrite("[Writing..]");            /* tell us were writing */
  894.  
  895.         lp = lforw(curbp->b_linep);             /* First line.          */
  896.  
  897.         nline = 0;                              /* Number of lines.     */
  898.  
  899.         while (lp != curbp->b_linep) {
  900.  
  901.                 if ((s=ffputline(&lp->l_text[0], llength(lp))) != FIOSUC)
  902.  
  903.                         break;
  904.  
  905.                 ++nline;
  906.  
  907.                 lp = lforw(lp);
  908.  
  909.         }
  910.  
  911.         if (s == FIOSUC) {                      /* No write error.      */
  912.  
  913.                 s = ffclose();
  914.  
  915.                 if (s == FIOSUC) {              /* No close error.      */
  916.  
  917.                         if (nline == 1)
  918.  
  919.                                 mlwrite("[Wrote 1 line]");
  920.  
  921.                         else
  922.  
  923.                                 mlwrite("[Wrote %d lines]", nline);
  924.  
  925.                 }
  926.  
  927.         } else                                  /* Ignore close error   */
  928.  
  929.                 ffclose();                      /* if a write error.    */
  930.  
  931.     TTkopen();
  932.  
  933.         if (s != FIOSUC)                        /* Some sort of error.  */
  934.  
  935.                 return (FALSE);
  936.  
  937.         return (TRUE);
  938.  
  939. }
  940.  
  941.  
  942.  
  943. /*
  944.  
  945.  * The command allows the user
  946.  
  947.  * to modify the file name associated with
  948.  
  949.  * the current buffer. It is like the "f" command
  950.  
  951.  * in UNIX "ed". The operation is simple; just zap
  952.  
  953.  * the name in the BUFFER structure, and mark the windows
  954.  
  955.  * as needing an update. You can type a blank line at the
  956.  
  957.  * prompt if you wish.
  958.  
  959.  */
  960.  
  961. filename(f, n)
  962.  
  963. {
  964.  
  965.         register WINDOW *wp;
  966.  
  967.         register int    s;
  968.  
  969.         char            fname[NFILEN];
  970.  
  971.  
  972.  
  973.     if (restflag)        /* don't allow this command if restricted */
  974.  
  975.         return(resterr());
  976.  
  977.         if ((s=mlreply("Name: ", fname, NFILEN)) == ABORT)
  978.  
  979.                 return (s);
  980.  
  981.         if (s == FALSE)
  982.  
  983.                 strcpy(curbp->b_fname, "");
  984.  
  985.         else
  986.  
  987.                 strcpy(curbp->b_fname, fname);
  988.  
  989.         wp = wheadp;                            /* Update mode lines.   */
  990.  
  991.         while (wp != NULL) {
  992.  
  993.                 if (wp->w_bufp == curbp)
  994.  
  995.                         wp->w_flag |= WFMODE;
  996.  
  997.                 wp = wp->w_wndp;
  998.  
  999.         }
  1000.  
  1001.     curbp->b_mode &= ~MDVIEW;    /* no longer read only mode */
  1002.  
  1003.         return (TRUE);
  1004.  
  1005. }
  1006.  
  1007.  
  1008.  
  1009. /*
  1010.  
  1011.  * Insert file "fname" into the current
  1012.  
  1013.  * buffer, Called by insert file command. Return the final
  1014.  
  1015.  * status of the read.
  1016.  
  1017.  */
  1018.  
  1019. ifile(fname)
  1020.  
  1021. char    fname[];
  1022.  
  1023. {
  1024.  
  1025.         register LINE   *lp0;
  1026.  
  1027.         register LINE   *lp1;
  1028.  
  1029.         register LINE   *lp2;
  1030.  
  1031.         register int    i;
  1032.  
  1033.         register BUFFER *bp;
  1034.  
  1035.         register int    s;
  1036.  
  1037.         register int    nbytes;
  1038.  
  1039.         register int    nline;
  1040.  
  1041.     int        lflag;        /* any lines longer than allowed? */
  1042.  
  1043.         char            line[NLINE];
  1044.  
  1045.  
  1046.  
  1047.         bp = curbp;                             /* Cheap.               */
  1048.  
  1049.         bp->b_flag |= BFCHG;            /* we have changed    */
  1050.  
  1051.     bp->b_flag &= ~BFINVS;            /* and are not temporary*/
  1052.  
  1053.         if ((s=ffropen(fname)) == FIOERR)       /* Hard file open.      */
  1054.  
  1055.                 goto out;
  1056.  
  1057.         if (s == FIOFNF) {                      /* File not found.      */
  1058.  
  1059.                 mlwrite("[No such file]");
  1060.  
  1061.         return(FALSE);
  1062.  
  1063.         }
  1064.  
  1065.         mlwrite("[Inserting file]");
  1066.  
  1067.  
  1068.  
  1069. #if    CRYPT
  1070.  
  1071.     s = resetkey();
  1072.  
  1073.     if (s != TRUE)
  1074.  
  1075.         return(s);
  1076.  
  1077. #endif
  1078.  
  1079.     /* back up a line and save the mark here */
  1080.  
  1081.     curwp->w_dotp = lback(curwp->w_dotp);
  1082.  
  1083.     curwp->w_doto = 0;
  1084.  
  1085.     curwp->w_markp = curwp->w_dotp;
  1086.  
  1087.     curwp->w_marko = 0;
  1088.  
  1089.  
  1090.  
  1091.         nline = 0;
  1092.  
  1093.     lflag = FALSE;
  1094.  
  1095.         while ((s=ffgetline(line, NLINE)) == FIOSUC || s == FIOLNG
  1096.  
  1097.             || s == FIOFUN) {
  1098.  
  1099.         if (s == FIOLNG) {
  1100.  
  1101.             lflag = TRUE;
  1102.  
  1103.             --nline;
  1104.  
  1105.         }
  1106.  
  1107.                 nbytes = strlen(line);
  1108.  
  1109.                 if ((lp1=lalloc(nbytes)) == NULL) {
  1110.  
  1111.                         s = FIOERR;             /* Keep message on the  */
  1112.  
  1113.                         break;                  /* display.             */
  1114.  
  1115.                 }
  1116.  
  1117.         lp0 = curwp->w_dotp;    /* line previous to insert */
  1118.  
  1119.         lp2 = lp0->l_fp;    /* line after insert */
  1120.  
  1121.  
  1122.  
  1123.         /* re-link new line between lp0 and lp2 */
  1124.  
  1125.         lp2->l_bp = lp1;
  1126.  
  1127.         lp0->l_fp = lp1;
  1128.  
  1129.         lp1->l_bp = lp0;
  1130.  
  1131.         lp1->l_fp = lp2;
  1132.  
  1133.  
  1134.  
  1135.         /* and advance and write out the current line */
  1136.  
  1137.         curwp->w_dotp = lp1;
  1138.  
  1139.                 for (i=0; i<nbytes; ++i)
  1140.  
  1141.                         lputc(lp1, i, line[i]);
  1142.  
  1143.                 ++nline;
  1144.  
  1145.                 if (s == FIOFUN)
  1146.  
  1147.                     break;
  1148.  
  1149.         }
  1150.  
  1151.         ffclose();                              /* Ignore errors.       */
  1152.  
  1153.     curwp->w_markp = lforw(curwp->w_markp);
  1154.  
  1155.     strcpy(line, "[");
  1156.  
  1157.     if (lflag)
  1158.  
  1159.         strcat(line, "Long lines wrapped, ");
  1160.  
  1161.     if (s == FIOFUN)
  1162.  
  1163.         strcat(line, "Funny line at EOF, ");
  1164.  
  1165.         if (s == FIOEOF || s == FIOFUN) {        /* Don't zap message!   */
  1166.  
  1167.         sprintf(&line[strlen(line)], "Inserted %d line", nline);
  1168.  
  1169.                 if (nline > 1)
  1170.  
  1171.             strcat(line, "s");
  1172.  
  1173.         strcat(line, "]");
  1174.  
  1175.         }
  1176.  
  1177.     if (s != FIOERR)
  1178.  
  1179.         mlwrite(line);
  1180.  
  1181. out:
  1182.  
  1183.     /* advance to the next line and mark the window for changes */
  1184.  
  1185.     curwp->w_dotp = lforw(curwp->w_dotp);
  1186.  
  1187.     curwp->w_flag |= WFHARD | WFMODE;
  1188.  
  1189.  
  1190.  
  1191.     /* copy window parameters back to the buffer structure */
  1192.  
  1193.     curbp->b_dotp = curwp->w_dotp;
  1194.  
  1195.     curbp->b_doto = curwp->w_doto;
  1196.  
  1197.     curbp->b_markp = curwp->w_markp;
  1198.  
  1199.     curbp->b_marko = curwp->w_marko;
  1200.  
  1201.  
  1202.  
  1203.         if (s == FIOERR)                        /* False if error.      */
  1204.  
  1205.                 return (FALSE);
  1206.  
  1207.         return (TRUE);
  1208.  
  1209. }
  1210.  
  1211.